#js 创建一个标签 document.createElement('标签')

#js 新建一个文本节点document.createTextNode('数据');

#js 获取父元素 parentNode

#js 获取子元素 lastElementChild

#js 获取某一个原生下面的第一个子节点  firstChild    firstElementChild  返回   为html

#js 获取某一个原生下面的最后一个子节点  lastChild   返回   为html

#js insertBefore(插入内容,位置) 方法在您指定的已有子节点之前插入新的子节点。

#html accept="image/gif, image/jpeg, image/png, image/jpg,video/* "  设置文件上传格式

#js getAttribute(‘自定义属性名称’) 获取自定义属性

#js setAttribute(‘属性名称’,'属性值') 设置标签自定义属性值

#js visibilitychange   事件监听页面上DOM的变化，只有页面上DOM出现显示或者是隐藏都会出现该事件

#js 扩展运算符（...），也可以用来收集参数 (仅限于方法)

#js 结构 可以用在方法上面结构  和返回数据的结构
 ====>默认参数 收集参数 展开参数
function aa([a,...b] = [6,8] ) {
	
}
对象默认参数
function getArr({ nums } = { nums: [1, 2, 3, 4] }){
   
}
getArr({nums:[5,4,3,2,1]}); // [5,4,3,2,1]

function addlis(name = 'admin', callback =  () =>{console.log(name)}){
	callback()
}
addlis()

===========结构,后台返回参数的结构 以及参数的收集

let b =  {
	rc: 0,
	des: "操作成功",
	data:{shidu: "74%",city: "霸州市",aqi: 289,pm25: 203,wendu: "-7",type: "阴",}
}
let {rc,...data} = b
console.log(rc)
console.log(data)




#js SE5~ES6默认参数

===========默认参数
ES5  let a = a || 9
>>>函数中
function a(a , b ) {    >>>ES5
	var a1 = a || 0;
	var a2 = b || 1
	return a1+a2;
} 
function b( a = 0 ,b = 1) {
	return a+b;
}

>>>>默认参数进行结构  数组
function getFirst([first, ...rest] = [0, 1]) {
  return first;
}

getFirst();  // 0
getFirst([10,20,30]);  // 10
>>>>默认参数进行结构  对象
function getArr({ nums } = { nums: [1, 2, 3, 4] }){
    return nums;
}

getArr(); // [1, 2, 3, 4]
getArr({nums:[5,4,3,2,1]}); // [5,4,3,2,1]

#js 显示转换和隐身转换
=====显示转换 (就是手动转换)
parseInt("12")
parseFloat("112.66")
======隐身转换('js自动转换  >>>隐式强制转换是一种将值转换为另一种类型的方法，这个过程是自动完成的，无需我们手动操作')

#js typeof()  只能返回数据类型

console.log(typeof 2);               // number
console.log(typeof true);            // boolean
console.log(typeof 'str');           // string
console.log(typeof []);              // object     []数组的数据类型在 typeof 中被解释为 object
console.log(typeof function(){});    // function
console.log(typeof {});              // object
console.log(typeof undefined);       // undefined
console.log(typeof null);            // object     null 的数据类型被 typeof 解释为 object


#js isNaN() 用法  

**** inNaN() 不管是 数字,还是字符串的数字 都返回 false  
inNaN()只能来判断 不是是数字, "98989" false  "qwqw" true
inNaN("999") // fasle 
inNaN(99) //fasle

inNaN("qwqw") //true

#js instanceof 只有引用数据类型（Array，Function，Object）被精准判断 其他（数值Number，布尔值Boolean，字符串String）字面值不能被instanceof精准判断 返回当前的1类型是不是我指定的类型 是就返回true


console.log(2 instanceof Number);                    // false
console.log(true instanceof Boolean);                // false 
console.log('str' instanceof String);                // false  这里是string 类型,但是不是string 对象 
console.log(new String('12312') instanceof(String))  //true   为string对象
console.log([] instanceof Array);                    // true
console.log(function(){} instanceof Function);       // true
console.log({} instanceof Object);                   // true  
#js 实例化对象??? 什么是实例化对象  把用类创建对象的过程称为实例化 (通常定义方法,在他的原型链(prototype)上面添加方法就需要实例化)

		new 关键字就是实例化对象
		new String('wwww')
		new Number(213321)
		new Array(1,3.12,4.5,2)
		new Object({a:1,b:2})


#js 判断是数组 Array.isArray()

=====只有数组才返回true 其他的类型全部为false
Array.isArray({})  // false
Array.isArray(5)	// false
Array.isArray("")	// false
Array.isArray(null)	// false
Array.isArray([])	// true
====浏览器不支持 Array.isArryay() 可用下
function isArray(value){
 return Object.prototype.toString.call(value) === "[object Array]"
}


#js  in 关键字  (用在 数组和对象里面) 返回true false

====Array
var trees = new Array("redwood", "bay", "cedar", "oak", "maple" ,'ok');
delete trees[0]   //删除下标为0
console.log(2 in trees) //true >>>下标2是存在的
console.log('length' in trees) //true >>>length是数组的属性是存在的

====Object
var pm = {m:'name',a:'age',z:18};
console.log('m' in pm)  //true  m 对象存在

var mycar = {make: "Honda", model: "Accord", year: 1998};
delete mycar.make;  //删除Honda
"make" in mycar;  // 返回false

===# hasOwnProperty() 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）

const o = { "prop" : "bwahahah","prop2" : "hweasa"};
console.log(o.hasOwnProperty("prop2")); // true

#js Object.freeze() 冻结,禁止增删查改 可以节省内存空间,提升速度

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js ES5面向对象写法
  function add(name,age) {  //类   也叫构造函数
	  this.name = name;
	  this.age = age;
  }
//在原型链上家方法
add.prototype.sex = function (sex)
{
	console.log(this.name)
	console.log(this.age)
	console.log(this.jonb)
	this.sex = sex;
}
//继承
function jonb (name,age,jonb) {
	add.call(this,name,age);
	this.jonb = jonb;
	console.log(add.call(this,name,age))
}
		jonb.prototype = new add();// 继承
		jonb.prototype.constructor = jonb; //添加 jonb方法
new jonb('李四',22,'javascript')
//一个对象要继承另一个对象,就用  add.call()
#js ES6面向对象写法

 class  Uer{ // 类
 	constructor(name,age) { //构造器
 	    this.name = name;
 		this.age = age;
 	}
 	//下面 name 和age 是扩展方法
 	UserName(){ //方法  
 		console.log(this.name)
 	}
 	UserAge(){
 		console.log(this.age)
 	}
 }
 /*方法调用*/
 // var zx = new Uer('自夏',18);
 // zx.UserName()
 // Vipuse (新的一个方法) extends(关键字) 继承 uer(已有的方法) 
 class Vipuser extends Uer{  //子类 
 	constructor(name,age,vip) { //子类构造器
 	    super(name,age);  //super 父类(用来继承uer 方法) 超类
 		this.vip = vip;
 	}
 	//新添加的方法
 	userleve(){
 		console.log(this.vip)
 	}
 }
 let u = new Vipuser('自夏','22',3);
 u.UserName()
 u.UserAge();
 u.userleve()


#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js

#js